package com.sweet.lang;

import com.sweet.json.JsonUtil;
import com.sweet.util.ConvertUtil;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.text.StringSubstitutor;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * 字符串工具类
 *
 * @author limi 2015-10-14
 */
public final class StringUtil {
    /**
     * 换行符列表
     * linux使用\n回车，windows使用\r\n回车，因此\n优先
     */
    private static final String[] NEW_LINE_SYMBOL = {"\n", "\r"};

    private StringUtil() {
    }

    /**
     * 判断是否为null或""
     *
     * @param cs
     * @return
     */
    public static boolean isEmpty(CharSequence cs) {
        return StringUtils.isEmpty(cs);
    }

    /**
     * 判断是否不为null或""
     *
     * @param text
     * @return
     */
    public static boolean isNotEmpty(CharSequence text) {
        return !isEmpty(text);
    }

    /**
     * 判断是否为null或空白字符串
     *
     * @param text
     * @return
     */
    public static boolean isBlank(CharSequence text) {
        return StringUtils.isBlank(text);
    }

    /**
     * 判断是否不为null或空白字符串
     *
     * @param text
     * @return
     */
    public static boolean isNotBlank(CharSequence text) {
        return !isBlank(text);
    }

    /**
     * 处理字符串空格
     *
     * @param text
     * @return
     */
    public static String trim(String text) {
        // 等价：StringUtils.trim()
        return text == null ? null : text.trim();
    }

    /**
     * 处理字符串空格，若字符串为空，则使用默认值
     *
     * @param value
     * @param defaultValue
     * @return
     */
    public static String trim(String value, String defaultValue) {
        String temp = trim(value);
        return isEmpty(temp) ? defaultValue : temp;
    }

    /**
     * 处理字符串空格
     *
     * @param text
     * @return null及空白字符串一律为""
     */
    public static String trimToEmpty(String text) {
        // 等价： StringUtils.trimToEmpty()
        return text == null ? "" : text.trim();
    }

    /**
     * 处理字符串空格
     *
     * @param text
     * @return null及空白字符串一律为null
     */
    public static String trimToNull(String text) {
        // 等价：StringUtils.trimToNull()
        String temp = trim(text);
        return isEmpty(temp) ? null : temp;
    }

    /**
     * 判断两个字符串是否一致
     *
     * @param str1
     * @param str2
     * @return
     */
    public static boolean equals(String str1, String str2) {
        return StringUtils.equals(str1, str2);
    }

    /**
     * 判断两个字符串是否一致，忽略大小写
     *
     * @param str1
     * @param str2
     * @return
     */
    public static boolean equalsIgnoreCase(String str1, String str2) {
        return StringUtils.equalsIgnoreCase(str1, str2);
    }

    /**
     * 忽略大小写检索字符串位置
     *
     * @param source 原字符串
     * @param search 查找字符串
     * @return
     */
    public static int indexOfIgnoreCase(String source, String search) {
        return StringUtils.indexOfIgnoreCase(source, search);
    }

    /**
     * 忽略大小写检索字符串位置
     *
     * @param source 原字符串
     * @param search 查找字符串
     * @return
     */
    public static int lastIndexOfIgnoreCase(String source, String search) {
        return StringUtils.lastIndexOfIgnoreCase(source, search);
    }

    /**
     * 拆分字符串
     *
     * @param text
     * @return
     */
    public static String[] split(String text, String chars) {
        return text == null ? null : StringUtils.split(text, chars);
    }

    /**
     * 拆分字符串
     *
     * @param text
     * @return
     */
    public static String[] splitByNewline(String text) {
        //拆分内容
        String[] datas = null;
        for (String symbol : NEW_LINE_SYMBOL) {
            datas = split(text, symbol);
            if (datas != null && datas.length > 0) {
                break;
            }
        }

        return datas;
    }

    /**
     * 拆分字符串，转为List
     *
     * @param str       字符串
     * @param separator 分割符号
     * @return
     */
    public static List<Integer> splitToIntList(String str, String separator) {
        // 拆分列表
        String[] array = isBlank(str) ? null : split(str, separator);
        if (array == null || array.length == 0) {
            return null;
        }

        // 定义列表
        List<Integer> list = new ArrayList();
        Integer id;
        for (String temp : array) {
            id = ConvertUtil.parseInt(temp.trim());
            if (id != null) {
                list.add(id);
            }
        }

        return list;
    }

    /**
     * 根据换行符拆分字符串，转为List
     * 备注：linux使用\n回车，windows使用\r\n回车，因此可采用\n优先拆分
     *
     * @param str 字符串
     * @return
     */
    public static List<Integer> splitToIntListByNewline(String str) {
        //拆分内容
        List<Integer> datas = null;
        for (String symbol : NEW_LINE_SYMBOL) {
            datas = splitToIntList(str, symbol);
            if (datas != null && datas.size() > 0) {
                break;
            }
        }

        return datas;
    }

    /**
     * 拆分字符串，转为List
     *
     * @param str       字符串
     * @param separator 分割符号
     * @return
     */
    public static List<String> splitToStringList(String str, String separator) {
        // 拆分列表
        String[] array = isBlank(str) ? null : split(str, separator);

        // 定义列表
        return (array == null || array.length == 0) ? null : Arrays.asList(array);
    }

    /**
     * 根据换行符拆分字符串，转为List
     * 备注：linux使用\n回车，windows使用\r\n回车，因此可采用\n优先拆分
     *
     * @param str 字符串
     * @return
     */
    public static List<String> splitToStringListByNewline(String str) {
        //拆分内容
        List<String> datas = null;
        for (String symbol : NEW_LINE_SYMBOL) {
            datas = splitToStringList(str, symbol);
            if (datas != null && datas.size() > 0) {
                break;
            }
        }

        return datas;
    }

    /**
     * 去掉字符串前缀
     *
     * @param str
     * @param prefix 前缀
     * @return
     */
    public static String deletePrefix(String str, String prefix) {
        return StringUtils.removeStart(str, prefix);
    }

    /**
     * 去掉字符串前缀,忽略大小写
     *
     * @param str
     * @param prefix 前缀
     * @return
     */
    public static String deletePrefixIgnoreCase(String str, String prefix) {
        return StringUtils.removeStartIgnoreCase(str, prefix);
    }

    /**
     * 去掉字符串后缀
     *
     * @param str
     * @param suffix 后缀
     * @return
     */
    public static String deleteSuffix(String str, String suffix) {
        return StringUtils.removeEnd(str, suffix);
    }

    /**
     * 去掉字符串后缀,忽略大小写
     *
     * @param str
     * @param suffix 后缀
     * @return
     */
    public static String deleteSuffixIgnoreCase(String str, String suffix) {
        return StringUtils.removeEndIgnoreCase(str, suffix);
    }

    /**
     * 隐藏部分字符串
     *
     * @param data
     * @param count
     * @param useEllipsis 是否使用省略号
     * @return
     */
    public static String hideString(final String data, int count, boolean useEllipsis) {
        if (StringUtil.isEmpty(data)) {
            return data;
        }

        String result = data;
        if (result.length() > count) {
            result = result.substring(0, count);
            if (useEllipsis) {
                result += "...";
            }
        }

        return result;
    }

    /**
     * 替换文本
     *
     * @param template 文本内容，使用命名参数：${参数名}占位
     * @param paramMap 参数值列表
     * @return
     */
    public static String format(String template, Map<String, Object> paramMap) {
        return new StringSubstitutor(paramMap).replace(template);
    }

    /**
     * 替换文本
     *
     * @param template
     * @param bean
     * @return
     */
    public static String format(String template, Object bean) {
        Map param = convertToMap(bean);
        return StringUtil.format(template, param);
    }

    /**
     * Java Bean转为map
     * 注意：必须配置Json参数
     *
     * @param bean
     * @return
     */
    public static Map<String, Object> convertToMap(Object bean) {
        if (bean == null) {
            return null;
        }

        if (bean instanceof Map) {
            return (Map) bean;
        }

        //转为Map
        return JsonUtil.toMap(bean);
    }
}